package cn.jinbyte.core.handler.crypt;

import cn.jinbyte.core.utils.NumUtils;

import java.lang.reflect.Array;

/**
 * 加解码处理器
 */
public interface CryptHandler {
    String SPLIT = ";";

    <T> String encode(T value);

    <T> T decode(String encryptedValue, Class<T> tClass);

    // 序列化对象为字符串（以 ; 分割数组）
    default <T> String serializeToString(T value, Class<?> tClass) {
        if (tClass.isArray()) {
            // 处理数组类型
            int length = Array.getLength(value);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < length; i++) {
                sb.append(Array.get(value, i));
                if (i < length - 1) sb.append(SPLIT);
            }
            return sb.toString();
        } else {
            // 处理单个对象
            return value.toString();
        }
    }

    // 从字符串解析对象（支持 ; 分割的数组）
    @SuppressWarnings("unchecked")
    default <T> T parseFromString(String rawValue, Class<T> tClass) {
        if (tClass.isArray()) {
            // 处理数组类型
            Class<?> componentType = tClass.getComponentType();
            String[] parts = rawValue.split(SPLIT);
            Object array = Array.newInstance(componentType, parts.length);

            for (int i = 0; i < parts.length; i++) {
                Object element = parseSingleValue(parts[i], componentType);
                Array.set(array, i, element);
            }
            return (T) array;
        } else {
            // 处理单个对象
            return (T) parseSingleValue(rawValue, tClass);
        }
    }

    // 解析单个值（支持 String 和 Number 类型）
    default Object parseSingleValue(String value, Class<?> targetType) {
        if (targetType == String.class) {
            return value;
        } else if (Number.class.isAssignableFrom(targetType)) {
            return NumUtils.parse(value, targetType);
        } else {
            throw new IllegalArgumentException("Unsupported type: " + targetType);
        }
    }
}
